home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / VERSION1.5 / GEMPOPUP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-26  |  11.6 KB  |  321 lines
  1. /*************************************************************************
  2.  *  GemUtil.C : Fonctions utilitaires pour WindForm.                     *
  3.  *************************************************************************/
  4.  
  5. #include "WindGem.h"
  6. #include "winproto.h"
  7.  
  8. /*-=< Section de declaration des fonctions privees >=--------------------*/
  9. static int  get_popup (OBJECT *adr, int button, int pu);
  10. static void set_popup (OBJECT *adr, int button, int option, int pu);
  11.  
  12. /*-----------------------------------------------------------------------*/
  13. static int get_popup (OBJECT *adr, int button, int pu)
  14. /*-----------------------------------------------------------------------*
  15.  * Chercher correspondance entre le texte d'un bouton et un formulaire   *
  16.  * pop-up.                                                               *
  17.  *-----------------------------------------------------------------------*/
  18. {
  19.     register int i = 1;
  20.     char bouton[MAX_LEN], option[MAX_LEN];
  21.     OBJECT *adrpu;
  22.  
  23.     if (! ((adr[button].ob_type >> 8) & POPUP_B))    /* Si pas pop-up */
  24.         return FALSE;                                                                /* Retourner 0 */
  25.  
  26.     rsrc_gaddr (R_TREE, pu, &adrpu);                        /* Adresse formulaire pop-up */
  27.  
  28.     strcpy (bouton, get_text (adr, button));        /* Lire le texte du bouton */
  29.     trim (bouton);                                                            /* Virer les espaces au début et à la fin */
  30.     do    /* Début de boucle : pour chaque objet du formulaire pop-up */
  31.     {
  32.         if (adrpu[i].ob_flags & SELECTABLE)                /* Si c'est un  SELECTABLE */
  33.         {
  34.             strcpy (option, get_text (adrpu, i));        /* Lire le texte de l'option */
  35.             trim (option);                                                    /* Virer les espaces au début et à la fin */
  36.             if (strcmp (bouton, option) == 0)                /* Si correspondance */
  37.                 return i;                                                            /* retourner le n° de l'option */
  38.         }
  39.     } while (! (adrpu[i++].ob_flags & LASTOB));    /* Fin de boucle : dernier objet */
  40.     return FALSE;                                                                /* Si pas occurence, retourner 0 */
  41. }
  42.  
  43. /*-----------------------------------------------------------------------*/
  44. static void set_popup (OBJECT *adr, int button, int option, int pu)
  45. /*-----------------------------------------------------------------------*
  46.  * Faire correspondre le texte d'un bouton pop-up avec celui d'une option*
  47.  *-----------------------------------------------------------------------*/
  48. {
  49.     char texte[MAX_LEN];
  50.     OBJECT *adrpu;
  51.  
  52.     if (! ((adr[button].ob_type >> 8) & POPUP_B))    /* Si pas pop-up */
  53.         return;                                                                            /* Ressortir */
  54.  
  55.     rsrc_gaddr (R_TREE, pu, &adrpu);                        /* Adresse formulaire pop-up */
  56.  
  57.     if ((adr[button].ob_type >> 8) & POPUP_B)        /* Si c'est bien un G_BUTTON */
  58.     {
  59.         strcpy (texte, get_text(adrpu, option));    /* Lire le texte de l'option */
  60.         trim (texte);                                                            /* Virer les espaces de début et de fin */
  61.         set_text (adr, button, texte);                        /* Copier le texte dans le bouton */
  62.     }
  63. }
  64.  
  65. /*-----------------------------------------------------------------------*/
  66. void pop_up (int arbre, int obj, int pu)
  67. /*-----------------------------------------------------------------------*
  68.  * Gestion d'un formulaire pop-up                                        *
  69.  *                                                                       *
  70.  * Si arbre = BLANK, pu est le popup appelé par clic droit de la souris  *
  71.  *-----------------------------------------------------------------------*/
  72. {
  73.     OBJECT *adr_pu, *adr;
  74.     int x, y, w, h, dummy, old_ob = -1, ob = 0, b[8], xm, ym, km,
  75.             evnt, sortie = FALSE, etat, old = 0;
  76.     MFDB image;
  77.     Wind *wind;
  78.  
  79.     rsrc_gaddr (R_TREE, pu, &adr_pu);    /* Adresse formulaire pop-up */
  80.  
  81.     if (arbre != BLANK)
  82.     {
  83.         wind = ObjListe(arbre);
  84.         adr = wind->cont.dialog->adr_form;
  85.         objc_offset (adr, obj, &x, &y);        /* Position bouton cliqué */
  86.         y += (adr[obj].ob_height);                /* Se placer juste dessous par défaut */
  87.     }
  88.     else
  89.     {
  90.         x = Sys->mousex;
  91.         y = Sys->mousey;
  92.     }
  93.  
  94.     adr_pu->ob_x = x;                                    /* Positionner le */
  95.     adr_pu->ob_y = y;                                    /* formulaire pop_up. */
  96.     w = adr_pu->ob_width + 1;                    /* Prendre ses */
  97.     h = adr_pu->ob_height + 1;                /* dimensions. */
  98.  
  99.     if (arbre != BLANK)
  100.         old = get_popup (adr, obj, pu);        /* Chercher correspondance */
  101.     else
  102.         old = 0;
  103.     
  104.     if (old)    /* Si le texte du bouton correspond déjà à une option du pop-up */
  105.     {    /* On fait coïncider les positions de l'option et du bouton */
  106.         x = adr_pu->ob_x = x - adr_pu[old].ob_x;
  107.         y = adr_pu->ob_y = y - adr_pu[old].ob_y - adr[obj].ob_height;
  108.         adr_pu[old].ob_state |= CHECKED;    /* On "Checke" l'option */
  109.     }
  110.  
  111.     if (x + w > Sys->Xdesk + Sys->Wdesk - 5)        /* Si on sort du bureau, décaler le pop-up */
  112.         x = adr_pu->ob_x = Sys->Wdesk + Sys->Xdesk - w - 5;    /* avec une marge de 5 pixels */
  113.     if (x < Sys->Xdesk + 5)
  114.         x = adr_pu->ob_x = Sys->Xdesk + 5;
  115.     if (y + h > Sys->Ydesk + Sys->Hdesk - 5)
  116.         y = adr_pu->ob_y = Sys->Hdesk + Sys->Ydesk - h - 5;
  117.     if (y < Sys->Ydesk + 5)
  118.         y = adr_pu->ob_y = Sys->Ydesk + 5;
  119.  
  120.     get_bkgr (x, y, w, h, &image);    /* Copier l'image de fond */
  121.     objc_draw (adr_pu, ROOT, MAX_DEPTH, x - 3, y - 3, w + 6, h + 6);    /* Dessiner le pop-up */
  122.  
  123.     /* Bloquer menu et événements MU_MESSAG */
  124.     wind_update(BEG_MCTRL);
  125.  
  126.     do    /* BOUCLE PRINCIPALE DE GESTION DU POP-UP */
  127.     {
  128.         evnt = evnt_multi (MU_BUTTON | MU_TIMER,    /* Seuls les clic et le timer nous intéressent */
  129.                                              1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  130.                                              b, 10, 0, &xm, &ym, &km, &dummy, &dummy, &dummy);
  131.         if (evnt & MU_BUTTON)                    /* Si événement de clic souris */
  132.         {
  133.             while (km)    /* On attend que le bouton de la souris soit relâché */
  134.                 graf_mkstate (&dummy, &dummy, &km, &dummy);
  135.             sortie = TRUE;    /* On peut sortir, puisqu'on a cliqué */
  136.         }
  137.         else if (evnt == MU_TIMER)    /* Si événement Timer */
  138.         {
  139.             graf_mkstate (&xm, &ym, &dummy, &dummy);    /* Demander coordonnées de la souris */
  140.  
  141.             /* Demander l'option de pop-up à cette position */
  142.             ob = objc_find (adr_pu, ROOT, MAX_DEPTH, xm, ym);
  143.             if (old_ob != ob && (adr_pu[ob].ob_flags & SELECTABLE))    /* Si option différente de la précédente */
  144.             {
  145.                 if ((old_ob != -1) && (! (adr_pu[old_ob].ob_state & DISABLED)))
  146.                 {    /* On désélectionne l'ancienne */
  147.                     etat = adr_pu[old_ob].ob_state & ~SELECTED;
  148.                     objc_change (adr_pu, old_ob, 0, x, y, w, h, etat, TRUE);
  149.                 }
  150.                 if ((ob > ROOT) && (! (adr_pu[ob].ob_state & DISABLED)) && (adr_pu[ob].ob_flags & SELECTABLE))
  151.                 {    /* Si la nouvelle option existe (on n'est pas sorti du pop-up)
  152.                          et si elle n'est pas DISABLED */
  153.                     etat = adr_pu[ob].ob_state | SELECTED;            /* On la sélectionne */
  154.                     objc_change (adr_pu, ob, 0, x, y, w, h, etat, TRUE);
  155.                 }
  156.                 old_ob = ob;    /* L'option courante devient l'ancienne option */
  157.             }
  158.         }
  159.     } while (sortie == FALSE);    /* Fin de boucle : tant qu'on n'a pas cliqué */
  160.  
  161.     /* Débloquer menu et événements MU_MESSAG */
  162.         wind_update(END_MCTRL);
  163.  
  164.     put_bkgr (x, y, w, h, &image);    /* Restaurer l'image de fond */
  165.     adr_pu[old].ob_state &= ~CHECKED;    /* Dé-checker l'option de départ */
  166.  
  167.     if ((ob > 0) && (! (adr_pu[ob].ob_state & DISABLED)) && (adr_pu[ob].ob_flags & SELECTABLE))
  168.     {    /* Si l'option existe (on n'est pas sorti du pop-up) et si elle n'est pas DISABLED */
  169.         etat = adr_pu[ob].ob_state &= ~SELECTED;                /* La désélectionner */
  170.         objc_change (adr_pu, ob, 0, x, y, w, h, etat, FALSE);
  171.         if (arbre != BLANK)
  172.             set_popup (adr, obj, ob, pu);            /* Copier son texte dans le bouton */
  173.         else /* Traiter l'option du popup */
  174.             (*Sys->popup)(ob);
  175.     }
  176.     if (arbre != BLANK)
  177.     {
  178.         ObjcUnselect (arbre, obj);
  179.         objc_draw (adr, obj, MAX_DEPTH,
  180.                              adr[ROOT].ob_x, adr[ROOT].ob_y,
  181.                              adr[ROOT].ob_width, adr[ROOT].ob_height);
  182.     }
  183. }
  184.  
  185. /*-----------------------------------------------------------------------*
  186.  * Fonction d'initialisation du popup menu appelé lors de l'appui sur le *
  187.  * bouton droit.                                                         *
  188.  *                                                                       *
  189.  * numObj     : Numéro de l'objet pour popup                               *
  190.  * gerePopup: Fonction de gestion du popup menu                          *
  191.  *-----------------------------------------------------------------------*/
  192. void PopMenu(int numObj, void (*gerePopup)(int option))
  193. {
  194.     if (numObj > 0 && gerePopup != (void *)NULL)
  195.     {
  196.         Sys->popMenu = numObj;
  197.         Sys->popup = gerePopup;
  198.     }
  199.  }
  200.  
  201. /*-----------------------------------------------------------------------*
  202.  * Fonction permettant d'associer un popup à un objet d'un formulaire.   *
  203.  *                                                                       *
  204.  * arbre    : Numéro de l'objet pour popup                                 *
  205.  * objet    : Fonction de gestion du popup menu                            *
  206.  * popup    : Arbre d'objet Popup                                          *
  207.  *-----------------------------------------------------------------------*/
  208. void AjoutePopup (int arbre, int objet, int ArbrePopup)
  209. {
  210.     Wind *wind;
  211.     POPUP *popup, *NewPopup;
  212.     WindForm *ptr_dial;
  213.     
  214.     if (arbre > 0 && objet > 0 && popup > 0)
  215.     {
  216.         wind = ObjListe(arbre);
  217.         if (wind != WIND_NULL)
  218.         {
  219.             ptr_dial = wind->cont.dialog;
  220.             
  221.             if (NewPopup = (POPUP *)malloc(sizeof(POPUP)));
  222.             {
  223.                 NewPopup->objet = objet;
  224.                 NewPopup->popup = ArbrePopup;
  225.                 NewPopup->suiv  = (POPUP *)NULL;
  226.             }            
  227.  
  228.             popup = ptr_dial->popup;
  229.             if (popup == (POPUP *)NULL)
  230.                 ptr_dial->popup = NewPopup;
  231.             else
  232.             {            
  233.                 while (popup->suiv != (POPUP *)NULL)
  234.                     popup = popup->suiv;
  235.                 popup->suiv = NewPopup;
  236.             }
  237.         }
  238.     }
  239. }
  240.  
  241. int IsPopup (Wind *wind, int objet)
  242. {
  243.     POPUP *popup;
  244.     WindForm *ptr_dial;
  245.     int ret = 0;
  246.     
  247.     ptr_dial = wind->cont.dialog;
  248.     popup = ptr_dial->popup;
  249.     while (popup != (POPUP *)NULL && popup->objet != objet)
  250.         popup = popup->suiv;
  251.     if (popup != (POPUP *)NULL)
  252.         ret = popup->popup;
  253.         
  254.     return ret;
  255. }
  256.  
  257. /*-----------------------------------------------------------------------*/
  258. void PopupNextValeur (int arbre, int obj, int popup)
  259. /*-----------------------------------------------------------------------*
  260.  * Chercher la valeur suivante dans un popup menu.                       *
  261.  *-----------------------------------------------------------------------*/
  262. {
  263.     register int i = 1;
  264.     int bon_obj, old_obj;
  265.     OBJECT *adrpu, *adr;
  266.     Wind *wind;
  267.  
  268.     wind = ObjListe(arbre);
  269.     adr = wind->cont.dialog->adr_form;
  270.  
  271.     rsrc_gaddr (R_TREE, popup, &adrpu);                /* Adresse formulaire pop-up */
  272.  
  273.     old_obj = get_popup (adr, obj, popup);            /* Chercher correspondance */
  274.     if (old_obj > 0)
  275.     {
  276.         if (adrpu[old_obj].ob_flags & LASTOB)
  277.             i = 1;
  278.         else
  279.             i = old_obj + 1;
  280.             
  281.         /* On cherche l'objet sélectionnable suivant */
  282.         do
  283.         {
  284.             if ((adrpu[i].ob_flags & SELECTABLE) && ! (adrpu[i].ob_state & DISABLED))
  285.                 break;
  286.             i++;
  287.         }    while (! (adrpu[i].ob_flags & LASTOB));
  288.  
  289.         if ((adrpu[i].ob_flags & SELECTABLE) && ! (adrpu[i].ob_state & DISABLED))
  290.             bon_obj = i;                                                            /* on le choisit         */
  291.         else                                                                                /* sinon                 */
  292.             bon_obj = old_obj;
  293.     }
  294.     else /* si rien de déjà sélectionné */
  295.     {
  296.         i = 1;
  297.  
  298.         /* On recherche depuis le début */
  299.         do
  300.         {
  301.             if ((adrpu[i].ob_flags & SELECTABLE) && ! (adrpu[i].ob_state & DISABLED))
  302.                 break;
  303.             i++;
  304.         }    while (! (adrpu[i].ob_flags & LASTOB));
  305.  
  306.         if ((adrpu[i].ob_flags & SELECTABLE) && ! (adrpu[i].ob_state & DISABLED))
  307.             bon_obj = i;                                                        /* on le choisit           */        
  308.         else 
  309.             bon_obj = -1;                                                        /* sinon tout DISABLE      */
  310.     }
  311.     if (bon_obj != -1)
  312.         set_popup (adr, obj, bon_obj, popup);            /* Affiche l'option        */
  313.  
  314.     ObjcUnselect (arbre, obj);
  315.     objc_draw (adr, obj, MAX_DEPTH,
  316.                          adr[ROOT].ob_x, adr[ROOT].ob_y,
  317.                          adr[ROOT].ob_width, adr[ROOT].ob_height);
  318. }
  319.  
  320. /**************************-=< Fin du module >=-**************************/
  321.